// $ANTLR 3.3 Nov 30, 2010 12:45:30 D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g 2013-09-13 02:37:05

package org.moflon.moca.blip.parser;
import java.util.Collection;
import Moca.MocaFactory;
import Moca.Problem;
import Moca.ProblemType;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class BlipLexer extends Lexer {
    public static final int EOF=-1;
    public static final int SLASH=4;
    public static final int COLON=5;
    public static final int AT=6;
    public static final int MINUS=7;
    public static final int LBRACE=8;
    public static final int RBRACE=9;
    public static final int BRACKETS=10;
    public static final int COMMA=11;
    public static final int SERVICETYPE=12;
    public static final int CR=13;
    public static final int LF=14;
    public static final int SPACE=15;
    public static final int TAB=16;
    public static final int LETTER=17;
    public static final int DIGIT=18;
    public static final int STRING=19;
    public static final int WS=20;
    public static final int COMMENT=21;

      public Collection<Problem> problems = new ArrayList<Problem>();

          public void displayRecognitionError(String[] tokenNames,
                                            RecognitionException e) {
              Problem problem = MocaFactory.eINSTANCE.createProblem();
              int line  = e.line;
              int charPos = e.charPositionInLine;
              int tokenLenght = 1;
              Token token = e.token;
              if(token != null) 
                tokenLenght = token.getText().length();
                      
              
              problem.setType(ProblemType.ERROR);
              problem.setLine(line); 
              problem.setCharacterPositionStart(charPos); 
              problem.setCharacterPositionEnd(charPos+tokenLenght);
              problem.setMessage("Lexer: " + getErrorMessage(e, tokenNames)); 
              
              problems.add(problem);
              super.displayRecognitionError(tokenNames, e);
        }


    // delegates
    // delegators

    public BlipLexer() {;} 
    public BlipLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public BlipLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g"; }

    // $ANTLR start "SLASH"
    public final void mSLASH() throws RecognitionException {
        try {
            int _type = SLASH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:37:7: ( '/' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:37:9: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SLASH"

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:39:7: ( ':' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:39:9: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "AT"
    public final void mAT() throws RecognitionException {
        try {
            int _type = AT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:41:4: ( '@' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:41:6: '@'
            {
            match('@'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AT"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:43:6: ( '-' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:43:8: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "LBRACE"
    public final void mLBRACE() throws RecognitionException {
        try {
            int _type = LBRACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:45:7: ( '{' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:45:9: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LBRACE"

    // $ANTLR start "RBRACE"
    public final void mRBRACE() throws RecognitionException {
        try {
            int _type = RBRACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:47:7: ( '}' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:47:9: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RBRACE"

    // $ANTLR start "BRACKETS"
    public final void mBRACKETS() throws RecognitionException {
        try {
            int _type = BRACKETS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:49:9: ( '[]' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:49:11: '[]'
            {
            match("[]"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BRACKETS"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:51:6: ( ',' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:51:8: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "SERVICETYPE"
    public final void mSERVICETYPE() throws RecognitionException {
        try {
            int _type = SERVICETYPE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:55:12: ( 'NATIVE' | 'STORAGE' | 'REST' )
            int alt1=3;
            switch ( input.LA(1) ) {
            case 'N':
                {
                alt1=1;
                }
                break;
            case 'S':
                {
                alt1=2;
                }
                break;
            case 'R':
                {
                alt1=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }

            switch (alt1) {
                case 1 :
                    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:55:14: 'NATIVE'
                    {
                    match("NATIVE"); 


                    }
                    break;
                case 2 :
                    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:55:25: 'STORAGE'
                    {
                    match("STORAGE"); 


                    }
                    break;
                case 3 :
                    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:55:37: 'REST'
                    {
                    match("REST"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SERVICETYPE"

    // $ANTLR start "CR"
    public final void mCR() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:58:12: ( '\\r' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:58:17: '\\r'
            {
            match('\r'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "CR"

    // $ANTLR start "LF"
    public final void mLF() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:59:12: ( '\\n' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:59:17: '\\n'
            {
            match('\n'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "LF"

    // $ANTLR start "SPACE"
    public final void mSPACE() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:60:15: ( ' ' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:60:20: ' '
            {
            match(' '); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "SPACE"

    // $ANTLR start "TAB"
    public final void mTAB() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:61:13: ( '\\t' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:61:18: '\\t'
            {
            match('\t'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "TAB"

    // $ANTLR start "LETTER"
    public final void mLETTER() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:63:16: ( 'a' .. 'z' | 'A' .. 'Z' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "LETTER"

    // $ANTLR start "DIGIT"
    public final void mDIGIT() throws RecognitionException {
        try {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:64:15: ( '0' .. '9' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:64:20: '0' .. '9'
            {
            matchRange('0','9'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "DIGIT"

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:65:7: ( ( '_' | LETTER | DIGIT | '.' )+ )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:65:9: ( '_' | LETTER | DIGIT | '.' )+
            {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:65:9: ( '_' | LETTER | DIGIT | '.' )+
            int cnt2=0;
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0=='.'||(LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='Z')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='z')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:
            	    {
            	    if ( input.LA(1)=='.'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STRING"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:66:4: ( ( ' ' | '\\t' | '\\f' | '\\n' | '\\r' )+ )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:66:6: ( ' ' | '\\t' | '\\f' | '\\n' | '\\r' )+
            {
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:66:6: ( ' ' | '\\t' | '\\f' | '\\n' | '\\r' )+
            int cnt3=0;
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0>='\t' && LA3_0<='\n')||(LA3_0>='\f' && LA3_0<='\r')||LA3_0==' ') ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);

            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:67:8: ( '//' ( . )* '\\n' )
            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:67:10: '//' ( . )* '\\n'
            {
            match("//"); 

            // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:67:15: ( . )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0=='\n') ) {
                    alt4=2;
                }
                else if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\uFFFF')) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:67:15: .
            	    {
            	    matchAny(); 

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            match('\n'); 
            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COMMENT"

    public void mTokens() throws RecognitionException {
        // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:8: ( SLASH | COLON | AT | MINUS | LBRACE | RBRACE | BRACKETS | COMMA | SERVICETYPE | STRING | WS | COMMENT )
        int alt5=12;
        alt5 = dfa5.predict(input);
        switch (alt5) {
            case 1 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:10: SLASH
                {
                mSLASH(); 

                }
                break;
            case 2 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:16: COLON
                {
                mCOLON(); 

                }
                break;
            case 3 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:22: AT
                {
                mAT(); 

                }
                break;
            case 4 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:25: MINUS
                {
                mMINUS(); 

                }
                break;
            case 5 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:31: LBRACE
                {
                mLBRACE(); 

                }
                break;
            case 6 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:38: RBRACE
                {
                mRBRACE(); 

                }
                break;
            case 7 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:45: BRACKETS
                {
                mBRACKETS(); 

                }
                break;
            case 8 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:54: COMMA
                {
                mCOMMA(); 

                }
                break;
            case 9 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:60: SERVICETYPE
                {
                mSERVICETYPE(); 

                }
                break;
            case 10 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:72: STRING
                {
                mSTRING(); 

                }
                break;
            case 11 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:79: WS
                {
                mWS(); 

                }
                break;
            case 12 :
                // D:\\MobileMDSD\\repo\\moflon\\BlipTGG\\src\\org\\moflon\\moca\\blip\\parser\\BlipLexer.g:1:82: COMMENT
                {
                mCOMMENT(); 

                }
                break;

        }

    }


    protected DFA5 dfa5 = new DFA5(this);
    static final String DFA5_eotS =
        "\1\uffff\1\17\7\uffff\3\14\4\uffff\10\14\1\33\2\14\1\uffff\1\33"+
        "\1\14\1\33";
    static final String DFA5_eofS =
        "\37\uffff";
    static final String DFA5_minS =
        "\1\11\1\57\7\uffff\1\101\1\124\1\105\4\uffff\1\124\1\117\1\123"+
        "\1\111\1\122\1\124\1\126\1\101\1\56\1\105\1\107\1\uffff\1\56\1\105"+
        "\1\56";
    static final String DFA5_maxS =
        "\1\175\1\57\7\uffff\1\101\1\124\1\105\4\uffff\1\124\1\117\1\123"+
        "\1\111\1\122\1\124\1\126\1\101\1\172\1\105\1\107\1\uffff\1\172\1"+
        "\105\1\172";
    static final String DFA5_acceptS =
        "\2\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\3\uffff\1\12\1\13\1\14\1"+
        "\1\13\uffff\1\11\3\uffff";
    static final String DFA5_specialS =
        "\37\uffff}>";
    static final String[] DFA5_transitionS = {
            "\2\15\1\uffff\2\15\22\uffff\1\15\13\uffff\1\10\1\4\1\14\1\1"+
            "\12\14\1\2\5\uffff\1\3\15\14\1\11\3\14\1\13\1\12\7\14\1\7\3"+
            "\uffff\1\14\1\uffff\32\14\1\5\1\uffff\1\6",
            "\1\16",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\20",
            "\1\21",
            "\1\22",
            "",
            "",
            "",
            "",
            "\1\23",
            "\1\24",
            "\1\25",
            "\1\26",
            "\1\27",
            "\1\30",
            "\1\31",
            "\1\32",
            "\1\14\1\uffff\12\14\7\uffff\32\14\4\uffff\1\14\1\uffff\32"+
            "\14",
            "\1\34",
            "\1\35",
            "",
            "\1\14\1\uffff\12\14\7\uffff\32\14\4\uffff\1\14\1\uffff\32"+
            "\14",
            "\1\36",
            "\1\14\1\uffff\12\14\7\uffff\32\14\4\uffff\1\14\1\uffff\32"+
            "\14"
    };

    static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
    static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
    static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
    static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
    static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
    static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
    static final short[][] DFA5_transition;

    static {
        int numStates = DFA5_transitionS.length;
        DFA5_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
        }
    }

    class DFA5 extends DFA {

        public DFA5(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 5;
            this.eot = DFA5_eot;
            this.eof = DFA5_eof;
            this.min = DFA5_min;
            this.max = DFA5_max;
            this.accept = DFA5_accept;
            this.special = DFA5_special;
            this.transition = DFA5_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( SLASH | COLON | AT | MINUS | LBRACE | RBRACE | BRACKETS | COMMA | SERVICETYPE | STRING | WS | COMMENT );";
        }
    }
 

}